import java.util.concurrent.CountDownLatch;

/**
 * @ClassName TestSF
 * @Description: TODO
 * @Author hl
 * @Date 2020/10/17
 * @Version V1.0
 **/
public class TestSF {
    public static void main(String[] args) {
        int []arr=getCloseNumber(2);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        CountDownLatch ct=new CountDownLatch(100);
    }

    public static int[] getCloseNumber(int num) {
        // write code here
        int[] result = null;
        int a = getPre(num);
        int b = getNext(num);
        if(a != -1 && b != -1){
            result = new int[2];
            result[0] = a;
            result[1] = b;
            return result;
        }
        else if(a != -1 && b == -1){
            result = new int[1];
            result[0] = a;
            return result;
        }
        else if(a == -1 && b != -1){
            result = new int[1];
            result[0] = b;
            return result;
        }
        return result;
    }

    public static int getNext(int n){
        int c = n;
        int c0 = 0;			//计算最右边的1的位置，都是从0开始计数
        int c1 = 0;			//计算非尾部的最右边的0的位置，是去掉尾部的0之后的位置
        while(((c & 1) == 0) && (c != 0)){	//当最后一位是1或者c等于0的时候停止
            c0++;
            c >>= 1;				//右移并用1填充
        }

        while((c & 1) == 1){	//因为上一步已经把最右边所有的零去掉，所以这里计算最右边的0的位置
            c1++;
            c >>= 1;
        }

        if(c0 + c1 == 31 || c0 + c1 == 0)
            return -1;

        int p = c0+c1;		//计算非尾部的最右边的0的位置

        n |= (1 << p);		//把非尾部的最右边的0翻转成1，计算大于的那个值
        n &= ~((1 << p) - 1);		//将p右边的所有位清0
        n |= (1 << (c1-1)) - 1;		//在右边插入(c1-1)个1

        return n;
    }

    public static int getPre(int n){
        int temp = n;
        int c0 = 0;		//计算最右边1的位置，是去掉尾部的1之后的位置
        int c1 = 0;		//计算最右边0的位置
      //  System.out.println("n="+Integer.toBinaryString(n));

        while((temp & 1) == 1){	//计算最右边0的位置
            c1++;
            temp >>= 1;
        }
     //   System.out.println("c1="+Integer.toBinaryString(c1));

        if(temp == 0)
            return -1;

        while(((temp & 1) == 0) && (temp != 0)){//当最后一位是1或者c等于0的时候停止
            c0++;																//计算最右边1的位置，去掉了尾部的1之后的位置
            temp >>= 1;
        }
       // System.out.println("c0="+Integer.toBinaryString(c0));

        int p = c0+c1;						//计算最右边1的位置
        n &= ((~0) << (p+1));			//将p右边的所有位清0（包括p），p是非尾部的最右边的1
      //  System.out.println("清零后："+Integer.toBinaryString(n));

        int mask = (1 << (c1 + 1)) - 1;		//c1+1个1，清零之后，需要补充c1+1个1
      //  System.out.println("补充1的个数："+Integer.toBinaryString(mask));

        n |= (mask << (c0 - 1));						//需要补充的1多大能是多少，然后和清零后的合并
      //  System.out.println("需要补充的1多大能是多少："+Integer.toBinaryString(mask << (c0 - 1)));

        return (n);
    }
}

